Controllo MQTT pianificato

suggerimento

Il controllo MQTT programmato è destinato ai messaggi programmati in anticipo. Per il controllo in tempo reale, vedere invece Live MQTT Control.

Questa guida ti aiuterà a configurare MQTT sul tuo SmartgridOne Controller per controllare e monitorare a distanza le installazioni di batterie e pannelli solari.

Cosa ti serve

1. SmartgridOne Controller con connettività internet.
2. Credenziali MQTT: possono essere richieste inviando un'email a support@eniris.be.
3. Ambiente di sviluppo Python (o qualsiasi altro client MQTT). Questa guida utilizza un esempio base scritto in Python per iniziare con MQTT e l'invio di comandi. Raccomandiamo di usare Python per la facilità d'uso, ma è supportato qualsiasi altro client MQTT.

Informazioni extra

MQTT è un protocollo di comunicazione veloce su Internet. È un sistema di messaggi publish/subscribe, che consente una connessione diretta tra la tua macchina e il SmartgridOne Controller. I tuoi asset sono classificati in gruppi di solare, batteria, veicoli elettrici e HVAC. Al momento, questa integrazione consente il controllo per gruppo, non per dispositivo.

Configurazione iniziale (Punto di partenza per nuovi utenti)

Ho un SmartgridOne Controller che vorrei impostare per il controllo remoto MQTT.

1. Controlla la tua rete

Assicurati che la tua rete consenta il traffico di rete mqtt sulla porta 1883. Puoi farlo utilizzando il comando:

nc -zv mqtt.eniris.be 1883

Quando questo comando non è disponibile, puoi alternativamente scaricare ed eseguire questo codice python.

Quando hai dei dubbi, consulta il tuo ingegnere di rete o utilizza temporaneamente il punto di accesso 4G/5G del tuo telefono quando si verificano errori di connessione.

note

Quando la porta 1883 non è accessibile dalla tua rete, offriamo un backup sulla porta 80. Questo può essere configurato nel tuo client MQTT in un passo successivo di questo manuale.

2. Aggiungi i tuoi dispositivi

Accedi all'interfaccia di commissioning e assicurati che i dispositivi siano aggiunti al SmartgridOne Controller.

3. Aggiungi il segnale esterno MQTT

4. Abilita il segnale remoto MQTT

Seleziona tutti i dispositivi che desideri includere nel Controllo Remoto MQTT.

5. Il segnale remoto è stato aggiunto

L'interfaccia di Controllo Remoto MQTT è stata ora attivata sul SmartgridOne Controller.

Siamo ora pronti a inviare alcuni comandi di base utilizzando un esempio semplice. La colonna di stato ti informa se un comando è attivo.

Script di demo Python

Un buon punto di partenza sarebbe testare la tua nuova integrazione con un esempio semplice.

Questo codice di test esegue un lavoro semplice inviando continuamente il seguente programma:

• Batteria: Carica a 5 kW per 15 minuti in 10 minuti
• Solare: Imposta la potenza a 0 kW per un'ora in 30 minuti

Il SmartgridOne Controller risponde con un messaggio di riconoscimento contenente l'identificatore univoco del programma, o un messaggio di errore.

Recuperiamo quindi il prossimo programma per entrambi i tipi di dispositivo, confermando che il comando è stato eseguito con successo.

Si prega di scaricare il file qui sotto nel proprio IDE Python preferito. Compila il tuo numero di serie e le credenziali MQTT ed esegui lo script:

Quando quanto sopra ha successo, puoi continuare con l'invio di altri tipi di messaggi. Tutti i messaggi sono descritti qui sotto.

Documentazione MQTT per l'invio di comandi

Questa sezione dettaglia il formato dei messaggi MQTT e i requisiti del payload per configurare il controllo programmato dei dispositivi all'interno della rete del SmartgridOne Controller.

Argomenti MQTT

• Topic di iscrizione: standard1/rp_one_s/remoteScheduleMetrics/<controller SN>
• Topic di feedback: standard1/outbound/remoteScheduleMetrics/feedback/<controller SN>

Dove <controller SN> deve essere sostituito con il numero di serie effettivo del SmartgridOne Controller che intendi controllare.

Tipi di Messaggi MQTT

1. Imposta Programma (set_schedule)

Crea un nuovo programma per un tipo di dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opzionale),
        "start_time": <Unix Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint in watt>,
        "replace_overlap": <True/False> (Opzionale) (default=False),
    }
}

Risposta (Successo):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <Schedule ID>,
            "deleted_ids": <Schedulde IDs deleted if replace_overlap=True>
        },
        "responseCode": 0
    }
}

2. Ottieni Programma (get_schedule)

Recupera un programma specifico per ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Risposta:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

3. Ottieni Programma Attivo (get_active_schedule)

Recupera il programma attualmente attivo per un tipo di dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_active_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opzionale),
    }
}

Risposta (Successo):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_active_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

4. Ottieni Prossimo Programma (get_next_schedule)

Recupera il prossimo programma in arrivo per un tipo di dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_next_schedule", 
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opzionale),
    }
}

Risposta (Successo):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_next_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

5. Ottieni Programmi (get_schedules)

Recupera tutti i programmi per una specifica data.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Date String of Format dd/mm/yyyy>"
    }
}

Response (Success):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

6. Ottieni Programmazioni Future (get_future_schedules)

Recupera tutte le programmazioni future.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_future_schedules",
    "fields": {}
}

Response (Success):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_future_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

7. Rimuovi Programmazione (remove_schedule)

Rimuove una programmazione specifica per ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "remove_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Response (Success):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Programmazione <Schedule ID> rimossa con successo",
        "responseCode": 0
    }
}

8. Ottieni Feedback dal Sito (get_feedback)

Recupera un feedback dettagliato sullo stato del sistema.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {}
}

Response (Success):

Struttura del Payload di Feedback

Formato di Risposta Standard per le Programmazioni

{
    "id": <Schedule ID>,
    "device_type": "<Device Type>",
    "node_id": "<Node ID>" (Opzionale),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Schedule Policy>",
    "power_setpoint_w": <Setpoint in watts>,
    "created_at": <Unix Timestamp>
}

Tipi di Componenti e Politiche

Per dettagli sui componenti disponibili e sulle politiche che possono essere programmate, fare riferimento alla sezione Componenti e Politiche MQTT nella documentazione di Live MQTT Control.

Le programmazioni specifiche del dispositivo possono essere inviate utilizzando il campo node_id opzionale, che fa riferimento all'ID del nodo del dispositivo controllabile.

Gestione degli Errori

Tutti i messaggi possono restituire una risposta di errore con responseCode: 1 quando si verifica un errore:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Message Type>_ack",
        "error": <Error Body>,
        "responseCode": 1
    }
}

Quando si verifica un errore non correlato, il tipo di messaggio sarà (general_error).

Gli errori comuni includono:

• Sovrapposizione di programmazioni con programmazioni esistenti
• Intervallo di tempo non valido
• Tipo di dispositivo non trovato
• ID programmazione non trovato
• Politica non valida per tipo di dispositivo

Regole di Gestione delle Programmazioni

1. Regole di Sovrapposizione
   • Le programmazioni non possono sovrapporsi per lo stesso tipo di dispositivo
   • Le programmazioni non possono sovrapporsi per lo stesso dispositivo
   • Le programmazioni per lo stesso dispositivo e tipo di dispositivo non possono sovrapporsi
   • Le programmazioni esistenti e sovrapposte saranno eliminate se la variabile replace_overlap è impostata su True durante la creazione di una nuova programmazione.
2. Ogni programmazione deve avere:
   • Un tipo di dispositivo valido
   • Un orario di inizio (timestamp Unix)
   • Un orario di fine (timestamp Unix)
   • Una politica (corrispondente alle politiche disponibili per il tipo di dispositivo)
   • Un setpoint di potenza (per le politiche che lo richiedono)
3. L'ora di inizio deve essere prima dell'ora di fine
4. L'ora di inizio deve essere almeno cinque minuti nel futuro
5. Le programmazioni possono essere cancellate solo se iniziano almeno cinque minuti nel futuro
6. Le programmazioni possono essere impostate per diversi tipi di dispositivi indipendentemente
7. Il sistema applica automaticamente la politica appropriata quando una programmazione diventa attiva